package proyectoCisco;

import java.sql.*;
import java.lang.Object.*;
import java.security.*;
import java.util.*;
import org.apache.log4j.Logger;

/**
 * Clase para el manejo de los datos y la base de datos
 * @author José Manuel Śanchez Bernabéu
 */
public class claseBBDD {
        
        public Connection c;
        private static Properties config = null;
        Logger log = Logger.getLogger(claseBBDD.class);

        /**
         * Contructor de la clase
         */
        public claseBBDD()
        {    
            try
            {
                config=Configurator.load();
                // Conector de la base de datos
                Class.forName("com.mysql.jdbc.Driver").newInstance();
                c = DriverManager.getConnection("jdbc:mysql://"+config.getProperty("serverMySQL")+":"+config.getProperty("port")+"/"+config.getProperty("database"),config.getProperty("user"),config.getProperty("password"));
                
                log.info("Conexión establecida con la base de datos "+"jdbc:mysql://"+config.getProperty("serverMySQL")+":"+config.getProperty("port")+"/"+config.getProperty("database"));
            }
            catch (Exception ex)
            { 
                log.error("Error al conectar con la base de datos o leer del fichero de configuración. Error: " + ex.getMessage());
            }
        }

        /**
         * Metodo que cierra la conexión con la base de datos
         */
        public void cerrarConexion()
        {
            try{
                c.close();
                log.info("Conexión cerrada correctamente con la base de datos");
            }
            catch(Exception e)
            {
                log.error("Error al cerrar la conexión con la base de datos. Error: "+e.getMessage());
            }
        }

        /**
         * Metodo que inserta un nuevo registro en la base de datos
         * @param tabla Nombre de la tabla a insertar el registro
         * @param nuevo Objeto a insertar en la tabla especificada
         */
        public void insertarRegistro(String tabla, Object nuevo)
        {
            try
            {
                Statement st = c.createStatement();
                String insertar = "";
                String valores="";

                if(tabla.equals("router"))
                {
                    Router router = new Router();
                    router = (Router)nuevo;
                    valores = "'" + router.getIp() + "','" + router.getMascara() + "','" + router.getNombre() + "','" + router.getSistemaOperativo() + "'";
                }
                else if(tabla.equals("usuario"))
                {
                    Usuario usuario = new Usuario();
                    usuario = (Usuario)nuevo;
                    valores = "'" + usuario.getIdUsuario() + "','" + usuario.getPassword() + "','" + usuario.getNombre() + "','" + usuario.getEmail() +"','"+ usuario.getUltimaConexion() +"','"+ usuario.getIp() +"','" + usuario.getTipoUsuario() +"'";
                }
                else if(tabla.equals("red"))
                {
                    Red red = new Red();
                    red = (Red)nuevo;
                    valores = "'" + red.getNombre() + "'";
                }
                else if(tabla.equals("routerUsuario"))
                {
                    RouterUsuario routerUsuario = new RouterUsuario();
                    routerUsuario = (RouterUsuario)nuevo;
                    valores = "'" + routerUsuario.getIp() + "','" + routerUsuario.getUsuario() + "'";
                }
                else if(tabla.equals("redRouter"))
                {
                    RedRouter redRouter = new RedRouter();
                    redRouter = (RedRouter)nuevo;
                    valores = "'" + redRouter.getRouter() + "','" + redRouter.getNombreRed() + "'";
                }
                
                insertar = "INSERT INTO "+ tabla + " VALUES(" + valores+")";

                log.info("Nuevo registro almacenado en la tabla '"+tabla+"'");
                log.debug("Registro almacenado en la tabla '"+tabla+"' . Cadena de inserción: "+insertar);

                st.executeUpdate(insertar);
                
                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al insertar un nuevo registro en la tabla '"+tabla+"'. Error: "+e.getMessage());
            }
        }

        /**
         * Metodo que elimina un registro de la base de datos
         * @param tabla Nombre de la tabla que se va a eliminar el registro
         * @param nuevo Objeto que se va a eliminar de la tabla
         * @return
         */
        public int borrarRegistro(String tabla, Object nuevo)
        {
            String registroId = "", campo = "";
            int retorno=0;

            try
            {
                Statement st = c.createStatement();
                String borrar = "";

                if(tabla.equals("router"))
                {
                    Router router = new Router();
                    router = (Router)nuevo;
                    registroId = "'" + router.getIp() + "'";
                    campo="ip";
                }
                else if(tabla.equals("usuario"))
                {
                    Usuario usuario = new Usuario();
                    usuario = (Usuario)nuevo;
                    registroId = "'" + usuario.getIdUsuario() + "'";
                    campo="idUsuario";
                }
                else if(tabla.equals("red"))
                {
                    Red red = new Red();
                    red = (Red)nuevo;
                    registroId = "'" + red.getNombre() + "'";
                    campo="nombreRed";
                }
                else if(tabla.equals("routerUsuario"))
                {
                    RouterUsuario routerUsuario = new RouterUsuario();
                    routerUsuario = (RouterUsuario)nuevo;
                    registroId = "'" + routerUsuario.getUsuario() + "'";
                    campo="usuario_usuario";
                }
                else if(tabla.equals("redRouter"))
                {
                    RedRouter redRouter = new RedRouter();
                    redRouter = (RedRouter)nuevo;
                    registroId = "'" + redRouter.getNombreRed() + "'";
                    campo="nombre_red";
                }
                
                borrar = "DELETE FROM "+tabla+" WHERE "+ campo +" = " + registroId+ ";";
                
                log.info("Registro borrado de la tabla '"+tabla+"'");
                log.debug("Registro borrado de la tabla '"+tabla+"' . Cadena de borrado: "+borrar);

                retorno=st.executeUpdate(borrar);
                
                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al borrar un registro de la tabla '"+tabla+"'. Error: "+e.getMessage());
            }
            return retorno;
        }

        /**
         * Metodo para editar un registro de la base de datos
         * @param tabla Tabla donde editar el registro
         * @param nuevo Nombre del registro que se va a editar
         */
        public void editarRegistro(String tabla, Object nuevo)
        {
            String valores = "",campo="",registroId=""; // campo del elemento para buscar el registro, registroId: id del elemento a modificar

            try
            {
                String editar="";
                Statement st = c.createStatement();
                
                if (tabla.equals("router"))
                {
                    Router router = new Router();
                    router = (Router)nuevo;
                    registroId = "'" + router.getIp() + "'";
                    valores = "mascara='" + router.getMascara() + "',nombre='" + router.getNombre() + "',sistOperativo='" + router.getSistemaOperativo() + "'";
                    campo="ip";
                }
                else if (tabla.equals("usuario"))
                {
                    Usuario usuario = new Usuario();
                    usuario = (Usuario)nuevo;
                    registroId = "'" + usuario.getIdUsuario() + "'";
                    if(usuario.getPassword()!=null)
                        valores = "password='" + usuario.getPassword() + "', nombre='" + usuario.getNombre() + "', email='" + usuario.getEmail() + "', ultimaConexion='" + usuario.getUltimaConexion() + "', ip='" + usuario.getIp() + "', ip='" + usuario.getIp() + "'";
                    else
                        valores = "nombre='" + usuario.getNombre() + "', email='" + usuario.getEmail() + "', ultimaConexion='" + usuario.getUltimaConexion() + "', ip='" + usuario.getIp() + "', ip='" + usuario.getIp() + "'";
                    campo="idUsuario";
                }
                
                editar = "UPDATE " + tabla + " SET "+valores+" WHERE "+ campo +"=" + registroId;

                log.info("Registro editado de la tabla '"+tabla+"'");
                log.debug("Registro editado de la tabla '"+tabla+"' . Cadena de edicion: "+editar);

                st.executeUpdate(editar);
                
                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al editar un registro de la tabla '"+tabla+"'. Error: "+e.getMessage());
            }
        }

        /**
         * Metodo que busca un registro en las tablas router o usuario
         * @param tabla Tabla donde buscar el registro
         * @param id Identificador del registro a buscar
         * @return
         */
        public Boolean buscarRegistro(String tabla, String id)
        {
            Boolean retorno = false;
            String buscar="";

            try
            {
                Statement st = c.createStatement();
                if(tabla.equals("router"))
                    buscar = "SELECT * FROM " + tabla + " WHERE ip='" + id + "'";
                else if(tabla.equals("usuario"))
                    buscar = "SELECT * FROM " + tabla + " WHERE idUsuario='" + id + "'";
                else if(tabla.equals("red"))
                    buscar = "SELECT * FROM " + tabla + " WHERE nombreRed='" + id + "'";

                ResultSet resultado;

                log.info("Buscando el registro '"+id+"' en la tabla '"+tabla+"'");
                log.debug("Buscando registro '"+id+"' en la tabla '"+tabla+"' . Cadena de busqueda: "+buscar);

                resultado=st.executeQuery(buscar);
                while(resultado.next())
                    return true;

                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al buscar el registro '"+id+"' en la tabla '"+tabla+"'. Error: "+e.getMessage());
            }
            
            return retorno;
        }

        /**
         * Metodo para comprobar las credenciales de un usuario
         * @param idUsuario Identificador de usuario
         * @param password Password del usuario
         * @return
         */
        public Boolean esCorrectaContrasenya(String idUsuario,String password)
        {
            Boolean retorno=false;
            String buscar="";
            try
            {
                Statement st = c.createStatement();
                
                buscar = "SELECT * FROM usuario WHERE idUsuario='" + idUsuario + "' and password='"+ password + "'";

                ResultSet resultado;

                log.info("Comprobando credenciales del usuario '"+idUsuario+"' en la base de datos");

                resultado=st.executeQuery(buscar);
                while(resultado.next())
                    retorno=true;

                st.close();

                if(retorno==false)
                    log.error("Intento de acceso del usuario '"+idUsuario + "' erróneo");
                else
                    log.info("Acceso permitido al usuario '"+idUsuario+"'");
            }
            catch(Exception e)
            {
                log.error("Error al comprobar credenciales del usuario '"+idUsuario+"' . Error: "+e.getMessage());
            }

            return retorno;
        }

        /**
         * Metodo para obtener el tipo de usuario que accede al sistema
         * @param idUsuario Identificador del usuario que accede al sistema
         * @return
         */
        public String getTipoUsuario(String idUsuario)
        {
            String retorno="",buscar="";

            try
            {
                Statement st = c.createStatement();

                buscar = "SELECT * FROM usuario WHERE idUsuario='" + idUsuario + "'";

                ResultSet resultado;

                log.info("Obteniendo tipo de usuario para el usuario '"+idUsuario+"' en la base de datos");
                log.debug("Obteniendo tipo de usuario para el usuario '"+idUsuario+"' en la base de datos. Cadena de búsqueda: "+buscar);

                resultado=st.executeQuery(buscar);
                while(resultado.next())
                    retorno=resultado.getString("tipoUsuario");

                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el tipo de usuario para el usuario '"+idUsuario+"' . Error: "+e.getMessage());
            }

            return retorno;
        }

        /**
         * Metodo que obtiene el listado de todos los routers del sistema
         * @return Array con los routers del sistema
         */
        public ArrayList ObtenerRouters()
        {
            Router router = new Router();
            ArrayList<Router> routers = new ArrayList<Router>();

            try
            {   
                Statement st = c.createStatement();
                String select = "SELECT * FROM router";
                ResultSet resultado;

                log.info("Obteniendo listado de routers de la base de datos");
                log.debug("Obteniendo listado de routers de la base de datos. Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    router = new Router();
                    router.setIp(resultado.getString("ip"));
                    router.setMascara(resultado.getString("mascara"));
                    router.setNombre(resultado.getString("nombre"));
                    router.setSistemaOperativo(resultado.getString("sistOperativo"));
                    routers.add(router);
                }
                
                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el listado de los routers . Error: "+e.getMessage());
            }

            return routers;
        }

        /**
         * Metodo que obtiene el listado de todos los routers del sistema asociados a un usuario
         * @return Array con los routers del sistema
         */
        public ArrayList<Router> ObtenerRouters(String idUsuario)
        {
            Router router = new Router();
            ArrayList<Router> routers = new ArrayList<Router>();

            try
            {
                Statement st = c.createStatement();
                String select = "SELECT * FROM routerUsuario WHERE usuario_usuario='"+ idUsuario +"'";
                ResultSet resultado;

                log.info("Obteniendo listado de routers de la base de datos para el usuario '"+idUsuario+"'");
                log.debug("Obteniendo listado de routers de la base de datos para el usuario '"+idUsuario+"'. Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    router = new Router();
                    router.setIp(resultado.getString("ip_router"));
                    router.setMascara(resultado.getString("usuario_usuario"));
                    routers.add(router);
                }

                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el listado de los routers para el usuario '"+idUsuario+"'. Error: "+e.getMessage());
            }
            return routers;
        }

        /**
         * Metodo que obtiene el listado de todos los routers del sistema
         * @return Array con los routers del sistema
         */
        public ArrayList<Red> ObtenerRedes()
        {
            Red red = new Red();
            ArrayList<Red> redes = new ArrayList<Red>();

            try
            {
                Statement st = c.createStatement();
                String select = "SELECT * FROM red";
                ResultSet resultado;

                log.info("Obteniendo listado de redes de la base de datos");
                log.debug("Obteniendo listado de redes de la base de datos. Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    red = new Red();
                    red.setNombre(resultado.getString("nombreRed"));
                    redes.add(red);
                }

                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el listado de redes . Error: "+e.getMessage());
            }

            return redes;
        }


        public boolean estaAsignadoRouterALista(Router router, ArrayList<Router> lista)
        {
           boolean retorno = false;

           for(int i=0;i<lista.size();i++)
           {
               if(router.getIp().equals(lista.get(i).getIp()))
               {
                   return true;
               }
           }


           return retorno;
        }


        /**
         * Metodo que obtiene el listado de todos los routers del sistema asociados a un usuario
         * @return Array con los routers del sistema
         */
        public ArrayList<Router> ObtenerRoutersRed(String idRed)
        {
            Router router = new Router();
            ArrayList<Router> routers = new ArrayList<Router>();

            try
            {
                Statement st = c.createStatement();
                String select = "SELECT * FROM redRouter WHERE nombre_red='"+ idRed +"'";
                ResultSet resultado;

                log.info("Obteniendo listado de routers de la base de datos de la red '"+idRed+"'");
                log.debug("Obteniendo listado de routers de la base de datos de la red '"+idRed+"'. Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    router = new Router();
                    router.setIp(resultado.getString("ip_router"));
                    routers.add(router);
                }

                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el listado de los routers de la red '"+idRed+"'. Error: "+e.getMessage());
            }
            return routers;
        }

        /**
         * Metodo que obtiene el listado de todos los routers del sistema NO asociados a ninguna red
         * @return Array con los routers del sistema
         */
        public ArrayList ObtenerRoutersNoAsignadosARed()
        {
            Router router = new Router();
            ArrayList<Router> routers = new ArrayList<Router>();

            try
            {
                Statement st = c.createStatement();
                String select = "SELECT ip FROM router where ip not in (select ip_router from redRouter)";
                ResultSet resultado;

                log.info("Obteniendo listado de routers de la base de datos no asignados a ninguna red");
                log.debug("Obteniendo listado de routers de la base de datos no asignados a ninguna red. Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    router = new Router();
                    router.setIp(resultado.getString("ip"));
                    routers.add(router);
                }
                
                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el listado de los routers no asignados a alguna red. Error: "+e.getMessage());
            }
            return routers;
        }

        /**
         * Metodo que obtiene el listado de usuario del sistema
         * @return Array con los usuarios del sistema
         */
        public ArrayList ObtenerUsuarios()
        {
            Usuario usuario = new Usuario();
            ArrayList<Usuario> usuarios = new ArrayList<Usuario>();

            try
            {   
                Statement st = c.createStatement();
                String select = "SELECT * FROM usuario";
                ResultSet resultado;

                log.info("Obteniendo listado de usuarios de la base de datos");
                log.debug("Obteniendo listado de usuarios de la base de datos. Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    usuario = new Usuario();
                    usuario.setIdUsuario(resultado.getString("idUsuario"));
                    usuario.setPassword(resultado.getString("password"));
                    usuario.setNombre(resultado.getString("nombre"));
                    usuario.setEmail(resultado.getString("email"));
                    usuario.setUltimaConexion(resultado.getString("ultimaConexion"));
                    usuario.setIp(resultado.getString("ip"));
                    usuario.setTipoUsuario(resultado.getString("tipoUsuario"));
                    usuarios.add(usuario);
                }
                
                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el listado de los usuarios. Error: "+e.getMessage());
            }
            return usuarios;
        }

        /**
         * Metodo que obtiene el listado de comandos almacenados en la base de datos
         * @return Array con los comandos de los routers
         */
        public ArrayList ObtenerComandos()
        {            
            ArrayList<String> comandos = new ArrayList<String>();

            try
            {
                Statement st = c.createStatement();
                String select = "SELECT * FROM comando";
                ResultSet resultado;

                log.info("Obteniendo listado de comandos de la base de datos para los routers");
                log.debug("Obteniendo listado de comandos de la base de datos para los routers. Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    comandos.add(resultado.getString("comando"));
                }

                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el listado de los comandos para los routers. Error: "+e.getMessage());
            }

            return comandos;
        }

        /**
         * Metodo que obtiene el listado de comandos almacenados en la base de datos
         * @return Array con los comandos de los routers
         */
        public ArrayList ObtenerInformacionComandos()
        {
            ArrayList<String> descripcion = new ArrayList<String>();

            try
            {
                Statement st = c.createStatement();
                String select = "SELECT * FROM comando";
                ResultSet resultado;

                log.info("Obteniendo listado de descripcion de comandos de la base de datos para los routers");
                log.debug("Obteniendo listado de descripcion de comandos de la base de datos para los routers. Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    descripcion.add(resultado.getString("descripcion"));
                }

                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el listado de descripcion de los comandos para los routers. Error: "+e.getMessage());
            }

            return descripcion;
        }

        /**
         * Metodo que obtiene todos los datos de un router
         * @param ip IP del router a obtener los datos
         * @return Toda la informacion del router
         */
        public Router ObtenerDatosRouter(String ip)
        {
            Router router = new Router();

            try
            {   
                Statement st = c.createStatement();
                String select = "SELECT * FROM router where ip='"+ip+"';";
                ResultSet resultado;

                log.info("Obteniendo informacion del router con IP: "+ip);
                log.debug("Obteniendo informacion del router con IP: "+ip+" . Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    router.setIp(resultado.getString("ip"));
                    router.setMascara(resultado.getString("mascara"));
                    router.setNombre(resultado.getString("nombre"));
                    router.setSistemaOperativo(resultado.getString("sistOperativo"));
                }
                
                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener la informacion para el router con IP: "+ip+" . Error: "+e.getMessage());
            }

            return router;
        }

        /**
         * Metodo que obtiene todos los datos de un usuario
         * @param idUsuario Identificador del usuario a obtener los datos
         * @return Toda la informacion del usuario
         */
        public Usuario ObtenerDatosUsuario(String idUsuario)
        {
            Usuario usuario = new Usuario();

            try
            {   
                Statement st = c.createStatement();
                String select = "SELECT * FROM usuario where idUsuario='"+idUsuario+"';";
                ResultSet resultado;

                log.info("Obteniendo informacion del usuario con idUsuario: "+idUsuario);
                log.debug("Obteniendo informacion del usuario con idUsuario: "+idUsuario+" . Cadena de búsqueda: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    usuario.setIdUsuario(resultado.getString("idUsuario"));
                    usuario.setPassword(resultado.getString("password"));
                    usuario.setNombre(resultado.getString("nombre"));
                    usuario.setEmail(resultado.getString("email"));
                }
                
                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener la informacion para el usuario con idUsuario: "+idUsuario+" . Error: "+e.getMessage());
            }

            return usuario;
        }

        /**
         * Metodo que almacena en la tabla usuario la ultima conexion establecida de ese usuario con el sistema
         * @param nuevo Usuario que establece la conexion
         */
        public void editarDatosAdicionalesUsuario(Object nuevo)
        {
            String valores = "",campo="",registroId=""; // campo del elemento para buscar el registro, registroId: id del elemento a modificar

            try
            {
                String editar="";
                Statement st = c.createStatement();

                Usuario usuario = new Usuario();
                usuario = (Usuario)nuevo;
                registroId = "'" + usuario.getIdUsuario() + "'";
                valores = "ultimaConexion='" + usuario.getUltimaConexion() + "', ip='" + usuario.getIp() + "'";
                campo="idUsuario";

                editar = "UPDATE usuario SET "+valores+" WHERE "+ campo +"=" + registroId;

                log.info("Editando datos adicionales del registro almacenado en la tabla 'Usuario'");
                log.debug("Editando datos adicionales del registro almacenado en la tabla 'Usuario' . Cadena de edición: "+editar);

                st.executeUpdate(editar);

                st.close();
            }
            catch(Exception e)
            {
                log.info("Error al editar los datos adicionales del registro almacenado en la tabla 'Usuario'. Error: "+e.getMessage());
            }
        }

        /**
         * Metodo que asigna a un usuario uno o varios routers para poder interactuar con él/ellos
         * @param idUsuario Identificador del usuario
         * @param routers Listado de routers a asignar al usuario
         * @return Ok si se ha hecho la asignacion correctamente
         */
        public String asignarRoutersUsuarios(String idUsuario, ArrayList<Router> routers)
        {
            String retorno="";
            try
            {
                // Borramos los routers asignados a ese usuario
                RouterUsuario routerUsuario = new RouterUsuario();
                routerUsuario.setUsuario(idUsuario);
                borrarRegistro("routerUsuario", routerUsuario);

                // Asignamos los nuevos routers al usuario
                for(int i=0;i<routers.size();i++)
                {
                    routerUsuario = new RouterUsuario(idUsuario,routers.get(i).getIp());
                    insertarRegistro("routerUsuario", routerUsuario);
                    log.info("Asignando router "+routers.get(i).getIp() +" al usuario '"+idUsuario+"'");
                }
                retorno="ok";
            }
            catch(Exception e)
            {
                log.error("Error al asignar un router al usuario '"+idUsuario+"' . Error: "+ e.getMessage());
            }

            return retorno;
        }

         /**
         * Metodo que asigna a una red uno o varios routers para poder
         * @param nombreRed Identificador de la red
         * @param routers Listado de routers a asignar al usuario
         * @return Ok si se ha hecho la asignacion correctamente
         */
        public String asignarRoutersRed(String nombreRed, ArrayList<Router> routers)
        {
            String retorno="";
            try
            {
                // Borramos los routers asignados a esta red
                RedRouter redRouter = new RedRouter();
                redRouter.setNombreRed(nombreRed);
                borrarRegistro("redRouter", redRouter);

                // Asignamos los nuevos routers al usuario
                for(int i=0;i<routers.size();i++)
                {
                    redRouter = new RedRouter(nombreRed,routers.get(i).getIp());
                    insertarRegistro("redRouter", redRouter);
                    log.info("Asignando router "+routers.get(i).getIp() +" a la red '"+nombreRed+"'");
                }
                retorno="ok";
            }
            catch(Exception e)
            {
                log.error("Error al asignar un router a la red '"+nombreRed+"' . Error: "+ e.getMessage());
            }

            return retorno;
        }

        /**
         * Metodo que obtiene el nombre de un router con ip ipRouter
         * @param ipRouter IP del router a obtener el nombre
         * @return Nombre del router
         */
        public String obtenerNombreRouter(String ipRouter)
        {
            String retorno = "";
            try
            {
                Statement st = c.createStatement();
                String select = "SELECT nombre FROM router where ip='"+ipRouter+"';";
                ResultSet resultado;

                log.info("Obteniendo el nombre del router con IP: "+ipRouter);
                log.debug("Obteniendo el nombre del router con IP: "+ipRouter+" . Cadena de consulta: "+select);

                resultado=st.executeQuery(select);
                while(resultado.next())
                {
                    retorno = resultado.getString("nombre");
                }

                st.close();
            }
            catch(Exception e)
            {
                log.error("Error al obtener el nombre del router con IP: "+ipRouter+" .Error "+e.getMessage());
            }
            return retorno;
        }

        /**
         * Metodo para encriptar las contraseñas de los usuario en la base de datos mediante el algoritmo MD5
         * @param password Password a encriptar
         * @return Cadena encriptada
         * @throws java.security.NoSuchAlgorithmException
         */
        public String encriptarContrasenya(String password) throws NoSuchAlgorithmException
        {
             char[] HEXADECIMAL = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
                                  '9', 'a', 'b', 'c', 'd', 'e', 'f' };
             try
             {
                   MessageDigest md = MessageDigest.getInstance("MD5");
                   byte[] bytes = md.digest(password.getBytes());
                   StringBuilder sb = new StringBuilder(2 * bytes.length);
                   for (int i = 0; i < bytes.length; i++)
                   {
                      int low = (int)(bytes[i] & 0x0f);
                      int high = (int)((bytes[i] & 0xf0) >> 4);
                      sb.append(HEXADECIMAL[high]);
                      sb.append(HEXADECIMAL[low]);
                   }
                   password=sb.toString();
                   log.debug("Encriptando la contraseña para el usuario.");
             }
             catch(Exception e)
             {
                 log.error("Error al encriptar la contraseña. Error: "+e.getMessage());
             }

             return password;
        }
}